前端背景抓取管理器：深入了解下载协调系统

            
async function startBackgroundFetch() {
 try {
 const registration = await navigator.serviceWorker.ready;
 const fetch = await registration.backgroundFetch.fetch(
 'my-download',
 ['/path/to/resource1.jpg', '/path/to/resource2.pdf'],
 {
 title: 'My Important Downloads',
 icons: [{
 src: '/icon.png',
 sizes: '512x512',
 type: 'image/png'
 }],
 downloadTotal: 1024 * 1024 * 100 // 100MB (approximate)
 }
 );

 fetch.addEventListener('progress', (event) => {
 const downloaded = event.downloaded;
 const total = event.downloadTotal;
 console.log(`Downloaded ${downloaded} of ${total}`);
 });

 fetch.addEventListener('backgroundfetchsuccess', () => {
 console.log('Download completed successfully!');
 });

 fetch.addEventListener('backgroundfetchfail', () => {
 console.error('Download failed!');
 });
 } catch (error) {
 console.error('Background Fetch API not supported or failed:', error);
 }
}

startBackgroundFetch();

            

              
                Copy
              
            
          

            
// service-worker.js

const CACHE_NAME = 'my-app-cache-v1';
const urlsToCache = [
 '/',
 '/styles/main.css',
 '/script/main.js',
 '/images/logo.png'
];

self.addEventListener('install', (event) => {
 event.waitUntil(
 caches.open(CACHE_NAME)
 .then((cache) => {
 console.log('Opened cache');
 return cache.addAll(urlsToCache);
 })
 );
});

self.addEventListener('fetch', (event) => {
 event.respondWith(
 caches.match(event.request)
 .then((response) => {
 // Cache hit - return response
 if (response) {
 return response;
 }
 return fetch(event.request).then(
 (response) => {
 // Check if we received a valid response
 if(!response || response.status !== 200 || response.type !== 'basic') {
 return response;
 }

 // IMPORTANT: Clone the response. A response is a stream
 // and because we want the cache to consume the response
 // as well as the browser to consume the response, we need
 // to clone it.
 var responseToCache = response.clone();

 caches.open(CACHE_NAME)
 .then((cache) => {
 cache.put(event.request, responseToCache);
 });

 return response;
 }
 );
 }
 )
 );
});

self.addEventListener('activate', (event) => {
 var cacheWhitelist = [CACHE_NAME];
 event.waitUntil(
 caches.keys().then((cacheNames) => {
 return Promise.all(
 cacheNames.map((cacheName) => {
 if (cacheWhitelist.indexOf(cacheName) === -1) {
 return caches.delete(cacheName);
 }
 })
 );
 })
 );
});

            

              
                Copy
              
            
          

            
class DownloadManager {
 constructor(maxParallelDownloads = 3) {
 this.queue = [];
 this.activeDownloads = 0;
 this.maxParallelDownloads = maxParallelDownloads;
 }

 addDownload(url, callback) {
 this.queue.push({ url, callback });
 this.processQueue();
 }

 processQueue() {
 while (this.activeDownloads < this.maxParallelDownloads && this.queue.length > 0) {
 const { url, callback } = this.queue.shift();
 this.activeDownloads++;
 this.downloadFile(url, callback);
 }
 }

 async downloadFile(url, callback) {
 try {
 const response = await fetch(url);
 if (!response.ok) {
 throw new Error(`HTTP error! status: ${response.status}`);
 }
 const blob = await response.blob();
 callback(blob, url);
 } catch (error) {
 console.error(`Error downloading ${url}:`, error);
 } finally {
 this.activeDownloads--;
 this.processQueue();
 }
 }
}

// Usage example
const downloadManager = new DownloadManager(2); // Allow 2 parallel downloads

downloadManager.addDownload('https://example.com/file1.pdf', (blob, url) => {
 console.log(`Downloaded ${url}`, blob);
 // Handle the downloaded blob (e.g., save to disk, display in UI)
});

downloadManager.addDownload('https://example.com/file2.jpg', (blob, url) => {
 console.log(`Downloaded ${url}`, blob);
 // Handle the downloaded blob
});


            

              
                Copy